import permision from '@/js_sdk/wa-permission/permission.js'

class VoiceRecorder {
  constructor() {
    this.recorderManager = uni.getRecorderManager()
    this.permisionID = 'android.permission.RECORD_AUDIO'
    this.isRecording = false
    this.uploadQueue = []
    this.isUploading = false
    this.cycleTimer = null
    this.recordingInterval = 3000 // 3秒
    this.reRecordDelay = 50 // 50ms后重新录音
    this.restartCount = 0 // 重启次数，最多3次

    this.setupRecorderEvents()
  }

  setupRecorderEvents() {
    // 录音开始事件
    this.recorderManager.onStart(() => {
      console.log('🎤 录音开始')
      this.isRecording = true
    })

    // 录音停止事件
    this.recorderManager.onStop(res => {
      console.log('⏹️ 录音停止', res.tempFilePath)
      this.isRecording = false
      if (res.tempFilePath) {
        console.log('录音文件路径:', res.tempFilePath)
        // 这里可以处理录音文件
        // this.handleRecordingComplete(res.tempFilePath)
      }
    })

    // 录音错误事件
    this.recorderManager.onError(res => {
      console.error('❌ 录音错误:', res)
      this.isRecording = false
      this.handleError(res)
    })
  }

  // 请求录音权限
  requestRecordPermission() {
    return new Promise(async (resolve, reject) => {
      const result = await permision.requestAndroidPermission(this.permisionID)
      if (result !== 1) {
        uni.showModal({
          title: '权限申请',
          content: '需要麦克风权限才能进行录音',
          success: res => {
            if (res.confirm) {
              console.log('用户确认授权')
              permision.gotoAppPermissionSetting()
            } else {
              console.log('用户拒绝授权')
              // 显示错误提示
              uni.showToast({
                title: '用户拒绝授权',
                icon: 'none',
                duration: 3000
              })
              reject(new Error('用户拒绝授权'))
            }
          }
        })
      } else {
        resolve()
      }
    })
  }

  // 开始连续录音
  async startContinuousRecording() {
    try {
      this.startRecordingCycle()
    } catch (error) {
      console.error('启动连续录音失败:', error)
    }
  }

  // 录音循环
  startRecordingCycle() {
    console.log('🔄 开始录音循环，每3秒上传一次')

    // 立即开始第一次录音
    this.start()

    // 设置定时器，每3秒停止并重新开始
    this.cycleTimer = setInterval(() => {
      if (this.isRecording) {
        console.log('⏰ 3秒到，停止当前录音')
        this.stop()
      }
    }, this.recordingInterval)
  }

  // 开始录音
  start(options = {}) {
    const defaultOptions = {
      duration: 60000, // 指定录音的时长，单位 ms
      sampleRate: 16000, // 采样率，有效值 8000/16000/44100
      format: 'aac' // 音频格式，有效值 aac/mp3/wav/PCM
    }

    // 先请求录音权限
    this.requestRecordPermission()
      .then(() => {
        this.recorderManager.start({ ...defaultOptions, ...options })
      })
      .catch(err => {
        console.error('录音权限获取失败:', err)
      })
  }

  // 处理录音完成
  async handleRecordingComplete(tempFilePath) {
    // 立即加入上传队列
    this.uploadQueue.push(tempFilePath)

    // 开始处理上传队列
    this.processUploadQueue()

    // 50ms后重新开始录音
    // setTimeout(() => {
    //   this.restartRecording()
    // }, this.reRecordDelay)
  }

  // 处理上传队列
  async processUploadQueue() {
    if (this.isUploading || this.uploadQueue.length === 0) {
      return
    }

    this.isUploading = true

    while (this.uploadQueue.length > 0) {
      const filePath = this.uploadQueue.shift()
      await this.uploadRecording(filePath)
    }

    this.isUploading = false
  }

  // 上传录音文件
  async uploadRecording(filePath) {
    try {
      console.log('📤 上传录音文件:', filePath)

      const result = await this.uploadToCloud(filePath)
      console.log('✅ 上传成功:', result)

      // 可以在这里处理云端返回的结果
      this.onUploadSuccess(result, filePath)
    } catch (error) {
      console.error('❌ 上传失败:', error)
      this.onUploadError(error, filePath)
    }
  }

  // 上传到云端
  uploadToCloud(filePath) {
    return new Promise((resolve, reject) => {
      uni.uploadFile({
        url: 'https://your-cloud-service.com/voice/upload',
        filePath: filePath,
        name: 'audio',
        formData: {
          timestamp: Date.now(),
          sessionId: this.getSessionId(),
          sequence: this.getSequenceNumber()
        },
        success: res => {
          const data =
            typeof res.data === 'string' ? JSON.parse(res.data) : res.data
          resolve(data)
        },
        fail: error => {
          reject(error)
        }
      })
    })
  }

  // 上传成功回调
  onUploadSuccess(result, filePath) {
    // 可以在这里处理云端返回的识别结果
    console.log('云端处理结果:', result)

    // 触发自定义事件
    this.emit('uploadSuccess', { result, filePath })
  }

  // 上传失败回调
  onUploadError(error, filePath) {
    console.error('上传失败:', error)

    // 触发自定义事件
    this.emit('uploadError', { error, filePath })
  }

  // 简单的事件系统
  emit(event, data) {
    if (this.eventListeners && this.eventListeners[event]) {
      this.eventListeners[event].forEach(callback => {
        callback(data)
      })
    }
  }

  on(event, callback) {
    if (!this.eventListeners) {
      this.eventListeners = {}
    }
    if (!this.eventListeners[event]) {
      this.eventListeners[event] = []
    }
    this.eventListeners[event].push(callback)
  }

  // 重新开始录音
  restartRecording() {
    if (!this.isRecording) {
      console.log('🔄 重新开始录音')
      this.start()
    }
  }

  // 安排重启（错误处理）
  scheduleRestart(error) {
    console.log('🕒 安排重启录音')
    setTimeout(() => {
      this.restartCount++
      if (this.restartCount > 3) {
        console.log('❌ 连续录音失败，请检查录音权限和录音设备是否正常')
        uni.showToast({
          title: `录音失败: ${error.errMsg}`,
          icon: 'none',
          duration: 3000
        })
      } else {
        this.restartRecording()
      }
    }, 100)
  }

  // 停止连续录音
  stopContinuousRecording() {
    console.log('🛑 停止连续录音')

    // 清理定时器
    if (this.cycleTimer) {
      clearInterval(this.cycleTimer)
      this.cycleTimer = null
    }

    // 停止当前录音
    this.stop()

    // 清空上传队列
    this.uploadQueue = []
    this.isUploading = false
  }

  // 停止录音
  stop() {
    if (this.isRecording) {
      this.recorderManager.stop()
    }
  }

  // 处理错误
  async handleError(error) {
    const result = await permision.requestAndroidPermission(this.permisionID)

    if (result !== 1) {
      // 显示错误提示
      uni.showToast({
        title: `录音失败: 麦克风权限被拒绝`,
        icon: 'none',
        duration: 3000
      })
    } else {
      this.scheduleRestart(error)
    }
    console.error('录音错误详情:', error.errMsg)
  }
}

export default new VoiceRecorder()
